home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / GXPrinterDrivers.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  36.8 KB  |  869 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        GXPrinterDrivers.p
  3.  
  4.      Contains:    This file defines data types and API functions for printer driver development.
  5.  
  6.      Version:    Technology:    Quickdraw GX 1.1
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT GXPrinterDrivers;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __GXPRINTERDRIVERS__}
  30. {$SETC __GXPRINTERDRIVERS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC GXPrinterDriversIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __SCALERTYPES__}
  38. {$I ScalerTypes.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    MixedMode.p                                                    }
  43. {    GXMath.p                                                    }
  44. {        FixMath.p                                                }
  45. {    SFNTTypes.p                                                    }
  46. {        GXTypes.p                                                }
  47.  
  48. {$IFC UNDEFINED __PRINTING__}
  49. {$I Printing.p}
  50. {$ENDC}
  51. {    Errors.p                                                    }
  52. {    Quickdraw.p                                                    }
  53. {        QuickdrawText.p                                            }
  54. {    Dialogs.p                                                    }
  55. {        Memory.p                                                }
  56. {        Menus.p                                                    }
  57. {        Controls.p                                                }
  58. {        Windows.p                                                }
  59. {            Events.p                                            }
  60. {                OSUtils.p                                        }
  61. {        TextEdit.p                                                }
  62.  
  63. {$IFC UNDEFINED __GXPRINTING__}
  64. {$I GXPrinting.p}
  65. {$ENDC}
  66. {    Collections.p                                                }
  67. {    Files.p                                                        }
  68. {        Finder.p                                                }
  69. {    GXFonts.p                                                    }
  70. {    Lists.p                                                        }
  71. {    GXMessages.p                                                }
  72.  
  73. {$PUSH}
  74. {$ALIGN MAC68K}
  75. {$LibExport+}
  76.  
  77. TYPE
  78.     gxManualFeedAlertPrefs = RECORD
  79.         alertFlags:                LONGINT;                                {    Flags--first word is for driver's private use, the rest is predefined. }
  80.     END;
  81.  
  82.     gxManualFeedAlertPrefsPtr = ^gxManualFeedAlertPrefs;
  83.     gxManualFeedAlertPrefsHdl = ^gxManualFeedAlertPrefsPtr;
  84.  
  85. { Constants for the alertFlags field of gxManualFeedAlertPrefs.}
  86.  
  87. CONST
  88.     gxShowAlerts                = $00000001;                    { Show alerts for this desktop printer. }
  89.     gxAlertOnPaperChange        = $00000002;                    { …only if the papertype changes. }
  90.  
  91.     gxDefaultMFeedAlertSettings    = 0+(gxShowAlerts + gxAlertOnPaperChange);
  92.  
  93. { Driver output settings structure for desktop printer gxDriverOutputType resource }
  94.  
  95. TYPE
  96.     gxDriverOutputSettings = RECORD
  97.         driverflags:            LONGINT;                                {    Flags -- for use by driver. }
  98.         outputSettings:            LONGINT;                                {    Flags -- predefined. }
  99.     END;
  100.  
  101.     gxDriverOutputSettingsPtr = ^gxDriverOutputSettings;
  102.     gxDriverOutputSettingsHdl = ^gxDriverOutputSettingsPtr;
  103.  
  104. { Constants for the outputSettings field of gxDriverOutputSettings. }
  105.  
  106. CONST
  107.     gxCanConfigureTrays            = $00000001;                    { Desktop printer represents a device with a paper feed. }
  108.  
  109. { ------------------------------------------------------------------------------
  110.  
  111.                         Printing Driver Constants and Types
  112.  
  113. -------------------------------------------------------------------------------- }
  114.     gxInputTraysMenuItem        = -1;                            { Menu item number for "Input Trays..." }
  115.  
  116. { Buffering and IO preferences-- this structure mirrors the 'iobm' resource }
  117.  
  118. TYPE
  119.     gxIOPrefsRec = RECORD
  120.         communicationsOptions:    LONGINT;                                { Standard or nonstandard I/O? }
  121.         numBuffers:                LONGINT;                                { Requested number of buffers for QDGX to create }
  122.         bufferSize:                LONGINT;                                { The size of each buffer }
  123.         numReqBlocks:            LONGINT;                                { The number of async I/O request blocks which will be needed }
  124.         openCloseTimeout:        LONGINT;                                { The open/close timeout (in ticks) }
  125.         readWriteTimeout:        LONGINT;                                { The read/write timeout (in ticks) }
  126.     END;
  127.  
  128.     gxIOPrefsPtr = ^gxIOPrefsRec;
  129.     gxIOPrefsHdl = ^gxIOPrefsPtr;
  130.  
  131. { Constants for the communicationsOptions field of IOPrefsRec. }
  132.  
  133. CONST
  134.     gxUseCustomIO                = $00000001;                    { Driver uses a non-standard IO mechanism }
  135.  
  136. { Information about writing to a file }
  137.  
  138. TYPE
  139.     gxPrintDestinationRec = RECORD
  140.         printToFile:            BOOLEAN;                                { True if output is to go to a file }
  141.         padByte:                CHAR;
  142.         fSpec:                    FSSpec;                                    { If going to a file, the FSSpec for the file }
  143.         includeFonts:            CHAR;                                    { True if fonts are to be included }
  144.         fileFormat:                Str31;                                    { Format to write file }
  145.     END;
  146.  
  147.     gxPrintDestinationPtr = ^gxPrintDestinationRec;
  148.     gxPrintDestinationHdl = ^gxPrintDestinationPtr;
  149.  
  150. { This structure is the content of each cell in the standard PACK LDEF }
  151.     gxPortListRec = RECORD
  152.         firstMarker:            CHAR;                                    { Markers to indicate icon or non-icon version }
  153.         secondMarker:            CHAR;                                    { if these are ≈ and ≈, then the cell is an icon cell. }
  154.         { Otherwise, it is assumed to be a standard text LDEF }
  155.         { cell }
  156.         iconSuiteHandle:        Handle;                                    { The icon suite to draw for this cell }
  157.         outputDriverName:        Handle;                                    { Handle to the output driver name (for serial) }
  158.         inputDriverName:        Handle;                                    { Handle to the input driver name (for serial) }
  159.         iconName:                Str255;                                    { Name to draw under the icon }
  160.     END;
  161.  
  162.     gxPortListPtr = ^gxPortListRec;
  163.  
  164. { ------------------------------------------------------------------------------
  165.  
  166.                         Printing Driver Constants for resources in the desktop printer
  167.  
  168. -------------------------------------------------------------------------------- }
  169.  
  170. CONST
  171.     gxDeviceCommunicationsID    = 0;
  172.  
  173. { ----------------------------------• 'prod' •---------------------------------- }
  174. {
  175.       For PostScript devices, the device and version names of the device.
  176.       (0) product name is of type PString
  177.       (1) version is of type PString
  178.       (2) revision is of type PString
  179.       (3) vm available is of type long
  180.       (4) font stream type is of type scalerStreamTypeFlag
  181.       (5) language level is of type long
  182. }
  183.     gxPostscriptProductInfoType    = 'prod';
  184.     gxPostscriptProductNameID    = 0;
  185.     gxPostscriptVersionID        = 1;
  186.     gxPostscriptRevisionID        = 2;
  187.     gxPostscriptVMAvailableID    = 3;
  188.     gxPostscriptFontStreamTypeID = 4;
  189.     gxPostscriptLanguageLevelID    = 5;
  190.  
  191. { ------------------------------------------------------------------------------
  192.  
  193.                         Printing Driver Constants for status alerts
  194.  
  195. -------------------------------------------------------------------------------- }
  196. { Structure passed in statusBuffer of StatusRecord for manual feed alert }
  197.  
  198. TYPE
  199.     gxManualFeedRecord = RECORD
  200.         canAutoFeed:            BOOLEAN;                                { True if driver can switch to auto feed }
  201.         paperTypeName:            Str31;                                    { Name of paperType to feed manually }
  202.     END;
  203.  
  204. { Structure passed in statusBuffer of StatusRecord for out of paper alert }
  205.     gxOutOfPaperRecord = RECORD
  206.         paperTypeName:            Str31;                                    { Name of printing document }
  207.     END;
  208.  
  209. { The DITL id for the auto feed button in the manual feed alert }
  210.  
  211. CONST
  212.     gxAutoFeedButtonId            = 3;
  213.  
  214. { Status resource id for the alerts }
  215.     gxUnivAlertStatusResourceId    = -28508;
  216.  
  217. { Status resource indices for alerts }
  218.     gxUnivManualFeedIndex        = 2;
  219.     gxUnivFailToPrintIndex        = 3;
  220.     gxUnivPaperJamIndex            = 4;
  221.     gxUnivOutOfPaperIndex        = 5;
  222.     gxUnivNoPaperTrayIndex        = 6;
  223.     gxUnivPrinterReadyIndex        = 7;
  224.     gxUnivAlertBeforeIndex        = 9;
  225.     gxUnivAlertAfterIndex        = 10;
  226.  
  227. { Allocation sizes for status buffers needed for automatic alerts }
  228.     gxDefaultStatusBufferSize    = 10;
  229.     gxManualFeedStatusBufferSize = 34;
  230.     gxOutOfPaperStatusBufferSize = 42;
  231.  
  232. { ------------------------------------------------------------------------------
  233.  
  234.                                 Old Application Support
  235.  
  236. -------------------------------------------------------------------------------- }
  237. { The format of a 'cust' resource  }
  238.  
  239. TYPE
  240.     gxCustomizationRec = RECORD
  241.         horizontalResolution:    INTEGER;                                { Horizontal res (integral part) }
  242.         verticalResolution:        INTEGER;                                { Vertical res (integral part) }
  243.         upDriverType:            INTEGER;                                { "upDriver" emulation type }
  244.         patternStretch:            Point;                                    { Pattern stretch factor }
  245.         translatorSettings:        INTEGER;                                { Translator settings to use }
  246.     END;
  247.  
  248.     gxCustomizationPtr = ^gxCustomizationRec;
  249.     gxCustomizationHdl = ^gxCustomizationPtr;
  250.  
  251. { The format of a 'resl' resource }
  252.     gxResolutionRec = RECORD
  253.         rangeType:                INTEGER;                                { Always 1 }
  254.         xMinimumResolution:        INTEGER;                                { Min X resolution available }
  255.         xMaximumResolution:        INTEGER;                                { Max X resolution available }
  256.         yMinimumResolution:        INTEGER;                                { Min Y resolution available }
  257.         yMaximumResolution:        INTEGER;                                { Max Y resolution available }
  258.         resolutionCount:        INTEGER;                                { Number of resolutions }
  259.         resolutions:            ARRAY [0..0] OF Point;                    { Array of resolutions }
  260.     END;
  261.  
  262.     gxResolutionPtr = ^gxResolutionRec;
  263.     gxResolutionHdl = ^gxResolutionPtr;
  264.  
  265. {
  266.  
  267.         Constants for the "universal" print record.
  268.  
  269. }
  270. { Constant for version number in universal print record }
  271.  
  272. CONST
  273.     gxPrintRecordVersion        = 8;
  274.  
  275. { Constants for feed field in universal print record }
  276.     gxAutoFeed                    = 0;
  277.     gxManualFeed                = 1;
  278.  
  279. { Constants for options field in universal print record }
  280.     gxPreciseBitmap                = $0001;                        { Tall adjusted (IW), precise bitmap (LW, SC) }
  281.     gxBiggerPages                = $0002;                        { No gaps (IW), larger print area (LW) }
  282.     gxGraphicSmoothing            = $0004;                        { Graphic smoothing (LW) }
  283.     gxTextSmoothing                = $0008;                        { Text smoothing (SC) }
  284.     gxFontSubstitution            = $0010;                        { Font substitution }
  285.     gxInvertPage                = $0020;                        { B/W invert image }
  286.     gxFlipPageHoriz                = $0040;                        { Flip horizontal }
  287.     gxFlipPageVert                = $0080;                        { Flip vertical }
  288.     gxColorMode                    = $0100;                        { Color printing }
  289.     gxBidirectional                = $0200;                        { Bidirectional printing }
  290.     gxUserFlag0                    = $0400;                        { User flag 0 }
  291.     gxUserFlag1                    = $0800;                        { User flag 1 }
  292.     gxUserFlag2                    = $1000;                        { User flag 2 }
  293.     gxReservedFlag0                = $2000;                        { Reserved flag 0 }
  294.     gxReservedFlag1                = $4000;                        { Reserved flag 1 }
  295.     gxReservedFlag2                = $8000;                        { Reserved flag 2 }
  296.  
  297. { Constants for orientation field in universal print record }
  298.     gxPortraitOrientation        = 0;
  299.     gxLandscapeOrientation        = 1;
  300.     gxAltPortraitOrientation    = 2;
  301.     gxAltLandscapeOrientation    = 3;
  302.  
  303. { Constants for qualityMode field in universal print record }
  304.     gxBestQuality                = 0;
  305.     gxFasterQuality                = 1;
  306.     gxDraftQuality                = 2;
  307.  
  308. { Constants for firstTray and remainingTray fields in universal print record }
  309.     gxFirstTray                    = 0;
  310.     gxSecondTray                = 1;
  311.     gxThirdTray                    = 2;
  312.  
  313. { Constants for coverPage field in universal print record }
  314.     gxNoCoverPage                = 0;
  315.     gxFirstPageCover            = 1;
  316.     gxLastPageCover                = 2;
  317.  
  318. { Constants for headMotion field in universal print record }
  319.     gxUnidirectionalMotion        = 0;
  320.     gxBidirectionalMotion        = 1;
  321.  
  322. { Constants for saveFile field in universal print record }
  323.     gxNoFile                    = 0;
  324.     gxPostScriptFile            = 1;
  325.  
  326. { The format of the "universal" print record }
  327.  
  328. TYPE
  329.     gxUniversalPrintRecord = RECORD
  330.         prVersion:                INTEGER;                                { Print record version }
  331.         {
  332.                                                         prInfo subrecord
  333.                                                 }
  334.         appDev:                    INTEGER;                                { Device kind, always 0 }
  335.         appVRes:                INTEGER;                                { Application vertical resolution }
  336.         appHRes:                INTEGER;                                { Application horizontal resolution }
  337.         appPage:                Rect;                                    { Page size, in application resolution }
  338.         appPaper:                Rect;                                    { Paper rectangle [offset from rPage] }
  339.         {
  340.                                                         prStl subrecord
  341.                                                 }
  342.         devType:                INTEGER;                                { Device type, always 0xA900 (was wDev) }
  343.         pageV:                    INTEGER;                                { Page height in 120ths of an inch }
  344.         pageH:                    INTEGER;                                { Page width in 120ths of an inch }
  345.         fillByte:                CHAR;                                    { Page calculation mode }
  346.         feed:                    CHAR;                                    { Feed mode }
  347.         {
  348.                                                         prInfoPT subrecord
  349.                                                 }
  350.         devKind:                INTEGER;                                { Device kind, always 0 }
  351.         devVRes:                INTEGER;                                { Device vertical resolution }
  352.         devHRes:                INTEGER;                                { Device horizontal resolution }
  353.         devPage:                Rect;                                    { Device page size }
  354.         {
  355.                                                         prXInfo subrecord
  356.                                                 }
  357.         actualCopies:            INTEGER;                                { Actual number of copies for this job }
  358.         options:                INTEGER;                                { Options for this device }
  359.         reduction:                INTEGER;                                { Reduce/enlarge factor }
  360.         orientation:            CHAR;                                    { Orientation of paper ( 0=portrait, 1=landscape ) }
  361.         {
  362.                                                         Clusters and PopUps
  363.                                                 }
  364.         qualityMode:            CHAR;                                    { Quality mode }
  365.         coverPage:                CHAR;                                    { Cover page }
  366.         firstTray:                CHAR;                                    { First feed tray }
  367.         remainingTray:            CHAR;                                    { Remaining feed tray }
  368.         headMotion:                CHAR;                                    { Head motion }
  369.         saveFile:                CHAR;                                    { Save file }
  370.         userCluster1:            CHAR;                                    { Three clusters left over }
  371.         userCluster2:            CHAR;
  372.         userCluster3:            CHAR;
  373.         {
  374.                                                         prJob subrecord
  375.                                                 }
  376.         firstPage:                INTEGER;                                { First page }
  377.         lastPage:                INTEGER;                                { Last page }
  378.         copies:                    INTEGER;                                { Number of copies, always 1 }
  379.         reserved1:                CHAR;                                    { Always true, unused }
  380.         reserved2:                CHAR;                                    { Always true, unused }
  381.         pIdleProc:                PrIdleUPP;                                { Idle proc }
  382.         pFileName:                Ptr;                                    { Spool file name pointer }
  383.         fileVol:                INTEGER;                                { Spool file vRefNum }
  384.         fileVers:                CHAR;                                    { File version, must be 0 }
  385.         reserved3:                CHAR;                                    { Always 0 }
  386.         printX:                    ARRAY [0..18] OF INTEGER;                { Internal use }
  387.     END;
  388.  
  389.     gxUniversalPrintRecordPtr = ^gxUniversalPrintRecord;
  390.     gxUniversalPrintRecordHdl = ^gxUniversalPrintRecordPtr;
  391.  
  392. { ------------------------------------------------------------------------------
  393.  
  394.                             Compatibility Printing Messages
  395.  
  396. -------------------------------------------------------------------------------- }
  397.  
  398. FUNCTION Forward_GXPrOpenDoc(hPrint: THPrint; VAR pPort: TPPrPort): OSErr; C;
  399. FUNCTION Forward_GXPrCloseDoc(pPort: TPPrPort): OSErr; C;
  400. FUNCTION Forward_GXPrOpenPage(pPort: TPPrPort; pRect: TPRect; resolution: Point): OSErr; C;
  401. FUNCTION Forward_GXPrClosePage(pPort: TPPrPort): OSErr; C;
  402. FUNCTION Forward_GXPrintDefault(hPrint: THPrint): OSErr; C;
  403. FUNCTION Forward_GXPrStlDialog(hPrint: THPrint; VAR confirmed: BOOLEAN): OSErr; C;
  404. FUNCTION Forward_GXPrJobDialog(hPrint: THPrint; VAR confirmed: BOOLEAN): OSErr; C;
  405. FUNCTION Forward_GXPrStlInit(hPrint: THPrint; VAR pDlg: TPPrDlgRef): OSErr; C;
  406. FUNCTION Forward_GXPrJobInit(hPrint: THPrint; VAR pDlg: TPPrDlgRef): OSErr; C;
  407. FUNCTION Forward_GXPrDlgMain(hPrint: THPrint; initProc: PDlgInitUPP; VAR confirmed: BOOLEAN): OSErr; C;
  408. FUNCTION Forward_GXPrValidate(hPrint: THPrint; VAR changedPrintRecord: BOOLEAN): OSErr; C;
  409. FUNCTION Forward_GXPrJobMerge(srcPrint: THPrint; destPrint: THPrint): OSErr; C;
  410. FUNCTION Forward_GXPrGeneral(dataPtr: Ptr): OSErr; C;
  411. FUNCTION Forward_GXConvertPrintRecordTo(hPrint: THPrint): OSErr; C;
  412. FUNCTION Forward_GXConvertPrintRecordFrom(hPrint: THPrint): OSErr; C;
  413. FUNCTION Forward_GXPrintRecordToJob(hPrint: THPrint; aJob: gxJob): OSErr; C;
  414. { ------------------------------------------------------------------------------
  415.  
  416.                         Raster Driver Contants and Types
  417.  
  418. -------------------------------------------------------------------------------- }
  419.     
  420. TYPE
  421.     gxRasterPlaneOptions = LONGINT;
  422.  
  423. { Input structure for setting up the offscreen }
  424.     gxPlaneSetupRec = RECORD
  425.         planeOptions:            gxRasterPlaneOptions;                    { Options for the offscreen package }
  426.         planeHalftone:            gxHalftone;                                { OPTIONAL: halftone structure for this plane }
  427.         planeSpace:                gxColorSpace;                            { OPTIONAL: noSpace will get the graphics default }
  428.         planeSet:                gxColorSet;                                { OPTIONAL: NIL gets the default }
  429.         planeProfile:            gxColorProfile;                            { OPTIONAL: NIL gets no matching }
  430.     END;
  431.  
  432. { Constants for planeOptions field in gxPlaneSetupRec }
  433.  
  434. CONST
  435.     gxDefaultOffscreen            = $00000000;                    { Default value - bits are allocated for the client, halftoning takes place }
  436.     gxDontSetHalftone            = $00000001;                    { Don't call SetViewPortHalftone }
  437.     gxDotTypeIsDitherLevel        = $00000002;                    { Call SetViewPortDither using the dotType as the level }
  438.  
  439.  
  440. TYPE
  441.     gxOffscreenSetupRec = RECORD
  442.         width:                    INTEGER;                                { Width in pixels }
  443.         minHeight:                INTEGER;                                { Minimum height in pixels - actual height returned here }
  444.         maxHeight:                INTEGER;                                { Maximum height in pixels }
  445.         ramPercentage:            Fixed;                                    { Maximum percentage of RAM to take }
  446.         ramSlop:                LONGINT;                                { Amount of RAM to be sure to leave }
  447.         depth:                    INTEGER;                                { Depths in bits of each plane }
  448.         vpMapping:                gxMapping;                                { Mapping to assign to offscreen viewPorts }
  449.         vdMapping:                gxMapping;                                { Mapping to assign to offscreen viewDevices }
  450.         planes:                    INTEGER;                                { Number of planes to allocate of depth bits each (can be more than 4) }
  451.         planeSetup:                ARRAY [0..3] OF gxPlaneSetupRec;        { Parameters for each plane, 4 is provided because it is most handy for writers of devices }
  452.     END;
  453.  
  454. { The format of one plane in the offscreen planar area }
  455.     gxOffscreenPlaneRec = RECORD
  456.         theViewPort:            gxViewPort;                                { viewPort for the offscreen }
  457.         theDevice:                gxViewDevice;                            { viewDevice for the offscreen }
  458.         theViewGroup:            gxViewGroup;                            { The viewGroup that they share }
  459.         theBitmap:                gxShape;                                { The offscreen bitmap shape }
  460.         theBits:                gxBitmap;                                { The bits of the offscreen }
  461.     END;
  462.  
  463. { The format of an entire offscreen area }
  464.     gxOffscreenRec = RECORD
  465.         numberOfPlanes:            INTEGER;                                { Number of planes we have }
  466.         offscreenStorage:        Handle;                                    { Handle containing the bitmaps image data }
  467.         thePlanes:                ARRAY [0..0] OF gxOffscreenPlaneRec;    { Planes to draw in }
  468.     END;
  469.  
  470.     gxOffscreenPtr = ^gxOffscreenRec;
  471.     gxOffscreenHdl = ^gxOffscreenPtr;
  472.  
  473.     gxRasterRenderOptions = LONGINT;
  474.  
  475. { Structure that mirrors 'rdip' resource. }
  476.     gxRasterPrefsRec = RECORD
  477.         renderOptions:            gxRasterRenderOptions;                    { Options for the raster imaging system }
  478.         hImageRes:                Fixed;                                    { Horizontal resolution to image at }
  479.         vImageRes:                Fixed;                                    { Vertical resolution to image at }
  480.         minBandSize:            INTEGER;                                { Minimum band size to use (in pixels) }
  481.         maxBandSize:            INTEGER;                                { Maximum band size to use (in pixels), 0 == entire page }
  482.         ramPercentage:            Fixed;                                    { Maximum percentage of RAM to take }
  483.         ramSlop:                LONGINT;                                { Amount of RAM to be sure to leave }
  484.         depth:                    INTEGER;                                { Depth in pixels (PER PLANE!) }
  485.         numPlanes:                INTEGER;                                { Number of planes to render }
  486.         planeSetup:                ARRAY [0..0] OF gxPlaneSetupRec;        { One for each plane }
  487.     END;
  488.  
  489. { Constants for renderOptions field in gxRasterPrefsRec. }
  490.  
  491. CONST
  492.     gxDefaultRaster                = $00000000;                    { Default raster options }
  493.     gxDontResolveTransferModes    = $00000001;                    { 0=Resolve, 1=Don't Resolve }
  494.     gxRenderInReverse            = $00000002;                    { Traverse image in reverse order }
  495.     gxOnePlaneAtATime            = $00000004;                    { Render each plane separately }
  496.     gxSendAllBands                = $00000008;                    { Send even empty bands }
  497.  
  498.     
  499. TYPE
  500.     gxRasterPrefsPtr = ^gxRasterPrefsRec;
  501.     gxRasterPrefsHdl = ^gxRasterPrefsPtr;
  502.  
  503.     gxRasterPackageOptions = LONGINT;
  504.  
  505. { Structure that mirrors 'rpck' resource. }
  506.     gxRasterPackageRec = RECORD
  507.         bufferSize:                Ptr;                                    { Buffer size for packaging (>= maximum head pass size) }
  508.         colorPasses:            INTEGER;                                { 1 (b/w) or 4 (CMYK) is typical }
  509.         headHeight:                INTEGER;                                { Printhead height in pixels }
  510.         numberPasses:            INTEGER;                                { Number of head passes it takes to == iHeadHeight }
  511.         passOffset:                INTEGER;                                { Offset between passes, in pixels }
  512.         packageOptions:            gxRasterPackageOptions;                    { Packaging options }
  513.     END;
  514.  
  515.     gxRasterPackagePtr = ^gxRasterPackageRec;
  516.     gxRasterPackageHdl = ^gxRasterPackagePtr;
  517.  
  518. { Constants for packageOptions field in gxRasterPackageRec. }
  519.  
  520. CONST
  521.     gxSendAllColors                = $00000001;                    { Send even clean bands through }
  522.     gxInterlaceColor            = $00000002;                    { Ribbon contamination is a concern }
  523.     gxOverlayColor                = $00000004;                    { Color printer without a ribbon problem }
  524.     gxUseColor                    = 0+(gxInterlaceColor + gxOverlayColor); { This is a color printer }
  525.  
  526. { Structure for RasterPackageBitmap message }
  527.  
  528. TYPE
  529.     gxRasterPackageBitmapRec = RECORD
  530.         bitmapToPackage:        ^gxBitmap;                                { Bitmap containing the data to package }
  531.         startRaster:            INTEGER;                                { Raster to begin the packaging from }
  532.         colorBand:                INTEGER;                                { For which color pass this is a packaging request }
  533.         isBandDirty:            BOOLEAN;                                { Whether there are any dirty bits in this band }
  534.         padByte:                CHAR;
  535.         dirtyRect:                Rect;                                    { Which bits are dirty }
  536.     END;
  537.  
  538. { Structure of number record in gxRasterPackageControlsRec }
  539.     gxStandardNumberRec = RECORD
  540.         numberType:                INTEGER;                                { Type of numberic output desired }
  541.         minWidth:                INTEGER;                                { Minimum output width of the number }
  542.         padChar:                CHAR;                                    { Pad character for numbers shorter than the minWidth }
  543.         padChar2:                CHAR;
  544.         startString:            Str31;                                    { Prefix string }
  545.         endString:                Str31;                                    { Postfix string }
  546.     END;
  547.  
  548.     gxStandardNumberPtr = ^gxStandardNumberRec;
  549.  
  550. { Structure that mirrors 'ropt' resource }
  551.     gxRasterPackageControlsRec = RECORD
  552.         startPageStringID:        INTEGER;                                { 'wstr' to send to the device at start of page }
  553.         formFeedStringID:        INTEGER;                                { 'wstr' to send to the device to cause a form feed }
  554.         forwardMax:                INTEGER;                                { Line feed strings }
  555.         forwardLineFeed:        gxStandardNumberRec;                    { Number record for forward line feed }
  556.         reverseMax:                INTEGER;                                { Max number of reverse line feeds device can do }
  557.         reverseLineFeed:        gxStandardNumberRec;                    { Number record for forward line feed }
  558.     END;
  559.  
  560.     gxRasterPackageControlsPtr = ^gxRasterPackageControlsRec;
  561.     gxRasterPackageControlsHdl = ^gxRasterPackageControlsPtr;
  562.  
  563. { Raster imaging system imageData structure }
  564.     gxRasterImageDataRec = RECORD
  565.         renderOptions:            gxRasterRenderOptions;                    { Options for the raster imaging system }
  566.         hImageRes:                Fixed;                                    { horizontal resolution to image at }
  567.         vImageRes:                Fixed;                                    { vertical resolution to image at }
  568.         minBandSize:            INTEGER;                                { smallest band that makes sense for this device }
  569.         maxBandSize:            INTEGER;                                { biggest band that makes sense, or 0 for "full page" }
  570.         pageSize:                gxRectangle;                            { size of page for device }
  571.         {
  572.             Values used within the RasterDataIn message
  573.     }
  574.         currentYPos:            INTEGER;                                { Current position moving down the page }
  575.         packagingInfo:            gxRasterPackageRec;                        { Raster packaging record }
  576.         {
  577.             Values used within the remaining messages
  578.     }
  579.         optionsValid:            BOOLEAN;                                { Were options specified by the driver? }
  580.         padByte:                CHAR;
  581.         packageControls:        gxRasterPackageControlsRec;                { Options for the packaging messages }
  582.         theSetup:                gxOffscreenSetupRec;                    { setup for the offscreen code, variable length componant }
  583.     END;
  584.  
  585.     gxRasterImageDataPtr = ^gxRasterImageDataRec;
  586.     gxRasterImageDataHdl = ^gxRasterImageDataPtr;
  587.  
  588. { ------------------------------------------------------------------------------
  589.  
  590.                                 Raster Driver Imaging Messages
  591.  
  592. -------------------------------------------------------------------------------- }
  593.  
  594. FUNCTION Send_GXRasterDataIn(offScreen: gxOffscreenHdl; VAR bandRectangle: gxRectangle; VAR dirtyRectangle: gxRectangle): OSErr; C;
  595. FUNCTION Forward_GXRasterDataIn(offScreen: gxOffscreenHdl; VAR bandRectangle: gxRectangle; VAR dirtyRectangle: gxRectangle): OSErr; C;
  596. FUNCTION Send_GXRasterLineFeed(VAR lineFeedSize: LONGINT; buffer: Ptr; VAR bufferPos: LONGINT; imageDataHdl: gxRasterImageDataHdl): OSErr; C;
  597. FUNCTION Forward_GXRasterLineFeed(VAR lineFeedSize: LONGINT; buffer: Ptr; VAR bufferPos: LONGINT; imageDataHdl: gxRasterImageDataHdl): OSErr; C;
  598. FUNCTION Send_GXRasterPackageBitmap(VAR whatToPackage: gxRasterPackageBitmapRec; buffer: Ptr; VAR bufferPos: LONGINT; imageDataHdl: gxRasterImageDataHdl): OSErr; C;
  599. FUNCTION Forward_GXRasterPackageBitmap(VAR whatToPackage: gxRasterPackageBitmapRec; buffer: Ptr; VAR bufferPos: LONGINT; imageDataHdl: gxRasterImageDataHdl): OSErr; C;
  600. { ------------------------------------------------------------------------------
  601.  
  602.                         Vector Driver Contants and Types
  603.  
  604. -------------------------------------------------------------------------------- }
  605. { Vector device halftone component record }
  606.  
  607. TYPE
  608.     gxVHalftoneCompRec = RECORD
  609.         angle:                    Fixed;                                    { Angle to halftone at. Must be 0, 90, 45 or 135 }
  610.         penIndex:                LONGINT;                                { index of the pen to draw this component with }
  611.     END;
  612.  
  613. { Vector device halftone record }
  614.     gxVHalftoneRec = RECORD
  615.         halftoneSpace:            gxColorSpace;
  616.         halftoneComps:            ARRAY [0..3] OF gxVHalftoneCompRec;        { Info for each color component }
  617.         penIndexForBW:            LONGINT;                                { Pen index to draw one bit deep or black and white bitmap with }
  618.     END;
  619.  
  620. { Vector shape rendering information }
  621.     gxVectorShapeOptions = LONGINT;
  622.  
  623.     gxVectorShapeDataRec = RECORD
  624.         shapeOptions:            gxVectorShapeOptions;                    { Options to control shape handling }
  625.         maxPolyPoints:            LONGINT;                                { Maximum number of polygon points that device can support }
  626.         shapeError:                Fixed;                                    { Defines allowed deviation from the original shape }
  627.         textSize:                Fixed;                                    { Text above this size is filled; text below this size is outlined }
  628.         frameSize:                Fixed;                                    { Frame's smaller than this -> shape stroked; frame's larger -> shape is filled }
  629.     END;
  630.  
  631. { Constants for shapeOptions field in gxVectorShapeDataRec. }
  632.  
  633. CONST
  634.     gxUnidirectionalFill        = $00000001;                    { Generate scanlines in one direction only.  Useful for transparencies }
  635.     gxAlsoOutlineFilledShape    = $00000002;                    { Turn on this bit to also outline solid filled shapes }
  636.  
  637. { Vector device rendering information }
  638.     
  639. TYPE
  640.     gxVectorRenderOptions = LONGINT;
  641.  
  642. { Vector imaging system imageData structure }
  643.     gxVectorImageDataRec = RECORD
  644.         renderOptions:            gxVectorRenderOptions;                    { Options to control rendering: color sort, clipping, etc. }
  645.         devRes:                    Fixed;                                    { Device resolution }
  646.         devTransform:            gxTransform;                            { Mapping, clip and halftoning information for colored bitmaps }
  647.         clrSet:                    gxColorSet;                                { Entire set of colors; usually indexed color space for pen plotters }
  648.         bgColor:                gxColor;                                { The background color in the color space specified by the clrSpace field }
  649.         halftoneInfo:            gxVHalftoneRec;                            { Defines halftone information for color bitmaps }
  650.         hPenTable:                gxPenTableHdl;                            { Complete list of pens along with their pen positions and thickness }
  651.         pageRect:                gxRectangle;                            { Page dimensions }
  652.         shapeData:                gxVectorShapeDataRec;                    { Information on how to render a shape }
  653.     END;
  654.  
  655.     gxVectorImageDataPtr = ^gxVectorImageDataRec;
  656.     gxVectorImageDataHdl = ^gxVectorImageDataPtr;
  657.  
  658. { Constants for renderOptions field in gxVectorImageDataRec. }
  659.  
  660. CONST
  661.     gxColorSort                    = $00000001;                    { Set for pen plotters }
  662.     gxATransferMode                = $00000002;                    { Set if transfer modes need to be resolved }
  663.     gxNoOverlap                    = $00000004;                    { Set if non-overlapping output is desired}
  664.     gxAColorBitmap                = $00000008;                    { Set if color bitmap output is desired }
  665.     gxSortbyPenPos                = $00000010;                    { Set if shapes are to be drawn in the order of the pen index }
  666. { in the pen table. NOTE: this is not the pen position in the carousel }
  667.     gxPenLessPlotter            = $00000020;                    { Indicates raster printer/plotter }
  668.     gxCutterPlotter                = $00000040;                    { Indicates cutter }
  669.     gxNoBackGround                = $00000080;                    { Set if shapes that map to the background color should not be sent to driver }
  670.  
  671. { ------------------------------------------------------------------------------
  672.  
  673.                                 Vector Driver Imaging Messages
  674.  
  675. -------------------------------------------------------------------------------- }
  676.  
  677. FUNCTION Send_GXVectorPackageShape(theShape: gxShape; penIndex: LONGINT): OSErr; C;
  678. FUNCTION Forward_GXVectorPackageShape(theShape: gxShape; penIndex: LONGINT): OSErr; C;
  679. FUNCTION Send_GXVectorLoadPens(penTable: gxPenTableHdl; VAR shapeCounts: LONGINT; VAR penTableChanged: BOOLEAN): OSErr; C;
  680. FUNCTION Forward_GXVectorLoadPens(penTable: gxPenTableHdl; VAR shapeCounts: LONGINT; VAR penTableChanged: BOOLEAN): OSErr; C;
  681. FUNCTION Send_GXVectorVectorizeShape(theShape: gxShape; penIndex: LONGINT; VAR vectorData: gxVectorShapeDataRec): OSErr; C;
  682. FUNCTION Forward_GXVectorVectorizeShape(theShape: gxShape; penIndex: LONGINT; VAR vectorData: gxVectorShapeDataRec): OSErr; C;
  683. { ------------------------------------------------------------------------------
  684.  
  685.                             PostScript Driver Contants and Types
  686.  
  687. -------------------------------------------------------------------------------- }
  688.  
  689. CONST
  690.     gxPostSynonym                = 'post';
  691.  
  692. { PostScript glyphs record }
  693.  
  694. TYPE
  695.     gxPrinterGlyphsRec = RECORD
  696.         theFont:                gxFont;                                    {  ---> Font reference }
  697.         nGlyphs:                LONGINT;                                {  ---> Number of glyphs in the font }
  698.         platform:                gxFontPlatform;                            { <---  How printer font is encoded }
  699.         script:                    gxFontScript;                            { <---  Script if platform != glyphPlatform }
  700.         language:                gxFontLanguage;                            { <---  Language if platform != glyphPlatform }
  701.         vmUsage:                LONGINT;                                { <---  How much PostScript VM font uses }
  702.         { Size of this array is long-alligned(nGlyphs) }
  703.         glyphBits:                ARRAY [0..0] OF LONGINT;                { <---  Bit array of which system glyphs are in printer }
  704.     END;
  705.  
  706. { PostScript device rendering information }
  707.     gxPostScriptRenderOptions = LONGINT;
  708.  
  709.     gxPostScriptImageDataRec = RECORD
  710.         languageLevel:            INTEGER;                                { PostScript language level }
  711.         devCSpace:                gxColorSpace;                            { The printer's color space }
  712.         devCProfile:            gxColorProfile;                            { The printer's color profile for matching }
  713.         renderOptions:            gxPostScriptRenderOptions;                { Options for the imaging system }
  714.         pathLimit:                LONGINT;                                { Maximum path size }
  715.         gsaveLimit:                INTEGER;                                { Maximum number of gsaves allowed }
  716.         opStackLimit:            INTEGER;                                { Operand stack limit }
  717.         fontType:                scalerStreamTypeFlag;                    { These are the font types that the printer supports  }
  718.         printerVM:                LONGINT;                                { How much memory is in the printer }
  719.         reserved0:                LONGINT;
  720.     END;
  721.  
  722.     gxPostScriptImageDataPtr = ^gxPostScriptImageDataRec;
  723.     gxPostScriptImageDataHdl = ^gxPostScriptImageDataPtr;
  724.  
  725. { Constants for renderOptions field in gxPostScriptImageDataRec. }
  726.  
  727. CONST
  728.     gxNeedsHexOption            = $00000001;                    { Convert all binary data to hex }
  729.     gxNeedsCommentsOption        = $00000002;                    { Issue PostScript comments }
  730.     gxBoundingBoxesOption        = $00000004;                    { Calculate the values for %%BoundingBox: and %%PageBoundingBox: -- requires needsCommentsOption }
  731.     gxPortablePostScriptOption    = $00000008;                    { Generate portable PostScript }
  732.     gxTextClipsToPathOption        = $00000010;                    { Convert all clips that are composed of text to path shapes }
  733.     gxFlattenClipPathOption        = $00000020;                    { Convert all clips that are path shapes to polygons (helps better control point limit) }
  734.     gxUseCharpath1Option        = $00000040;                    { (ignored if text clips are converted to paths)  When the clip is text,  }
  735. { Do it one glyph at a time, redrawing the main shape each time }
  736.     gxUseLevel2ColorOption        = $00000080;                    { When printing to level-2 use level-2 device independent color }
  737.     gxNoEPSIllegalOperators        = $00000100;                    { Don't use any operators prohibited by the Encapsulated PostScript File Format V3.0 }
  738.     gxEPSTargetOption            = gxNoEPSIllegalOperators + gxNeedsCommentsOption + gxBoundingBoxesOption; { PostScript intended for EPS Use. }
  739.  
  740. { Structure for gxPostScriptGetProcSetList / gxPostScriptDownLoadProcSetList }
  741.  
  742. TYPE
  743.     gxProcSetListRec = RECORD
  744.         clientid:                gxOwnerSignature;
  745.         controlType:            OSType;                                    { The driver will call FetchTaggedData on each of these resources }
  746.         controlid:                INTEGER;
  747.         dataType:                OSType;
  748.         reserved0:                LONGINT;
  749.     END;
  750.  
  751.     gxProcSetListPtr = ^gxProcSetListRec;
  752.     gxProcSetListHdl = ^gxProcSetListPtr;
  753.  
  754. { Possible results of querying printer (returned by gxPostScriptQueryPrinter message) }
  755.  
  756. CONST
  757.     gxPrinterOK                    = 0;
  758.     gxIntializePrinter            = 1;
  759.     gxFilePrinting                = 2;
  760.     gxResetPrinter                = 128;
  761.  
  762. { ------------------------------------------------------------------------------
  763.  
  764.                                 PostScript Driver Imaging Messages
  765.  
  766. -------------------------------------------------------------------------------- }
  767.  
  768. FUNCTION Send_GXPostScriptQueryPrinter(VAR queryData: LONGINT): OSErr; C;
  769. FUNCTION Forward_GXPostScriptQueryPrinter(VAR queryData: LONGINT): OSErr; C;
  770. FUNCTION Send_GXPostScriptInitializePrinter: OSErr; C;
  771. FUNCTION Forward_GXPostScriptInitializePrinter: OSErr; C;
  772. FUNCTION Send_GXPostScriptResetPrinter: OSErr; C;
  773. FUNCTION Forward_GXPostScriptResetPrinter: OSErr; C;
  774. FUNCTION Send_GXPostScriptExitServer: OSErr; C;
  775. FUNCTION Forward_GXPostScriptExitServer: OSErr; C;
  776. {
  777.  
  778.         Device communication messages
  779.  
  780. }
  781. FUNCTION Send_GXPostScriptGetStatusText(textHdl: Handle): OSErr; C;
  782. FUNCTION Forward_GXPostScriptGetStatusText(textHdl: Handle): OSErr; C;
  783. FUNCTION Send_GXPostScriptGetPrinterText(textHdl: Handle): OSErr; C;
  784. FUNCTION Forward_GXPostScriptGetPrinterText(textHdl: Handle): OSErr; C;
  785. FUNCTION Send_GXPostScriptScanStatusText(textHdl: Handle): OSErr; C;
  786. FUNCTION Forward_GXPostScriptScanStatusText(textHdl: Handle): OSErr; C;
  787. FUNCTION Send_GXPostScriptScanPrinterText(textHdl: Handle): OSErr; C;
  788. FUNCTION Forward_GXPostScriptScanPrinterText(textHdl: Handle): OSErr; C;
  789. {
  790.  
  791.         Proc set management messages
  792.  
  793. }
  794. FUNCTION Send_GXPostScriptGetDocumentProcSetList(procSet: gxProcSetListHdl; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  795. FUNCTION Forward_GXPostScriptGetDocumentProcSetList(procSet: gxProcSetListHdl; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  796. FUNCTION Send_GXPostScriptDownloadProcSetList(procSet: gxProcSetListHdl; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  797. FUNCTION Forward_GXPostScriptDownloadProcSetList(procSet: gxProcSetListHdl; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  798. {
  799.  
  800.         Font management messages
  801.  
  802. }
  803. FUNCTION Send_GXPostScriptGetPrinterGlyphsInformation(VAR glyphsInfo: gxPrinterGlyphsRec): OSErr; C;
  804. FUNCTION Forward_GXPostScriptGetPrinterGlyphsInformation(VAR glyphsInfo: gxPrinterGlyphsRec): OSErr; C;
  805. FUNCTION Send_GXPostScriptStreamFont(fontref: gxFont; VAR streamPtr: scalerStream): OSErr; C;
  806. FUNCTION Forward_GXPostScriptStreamFont(fontref: gxFont; VAR streamPtr: scalerStream): OSErr; C;
  807. {
  808.  
  809.         Document structuring and formatting messages
  810.  
  811. }
  812. FUNCTION Send_GXPostScriptDoDocumentHeader(imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  813. FUNCTION Forward_GXPostScriptDoDocumentHeader(imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  814. FUNCTION Send_GXPostScriptDoDocumentSetup(imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  815. FUNCTION Forward_GXPostScriptDoDocumentSetup(imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  816. FUNCTION Send_GXPostScriptDoDocumentTrailer(imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  817. FUNCTION Forward_GXPostScriptDoDocumentTrailer(imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  818. {
  819.  
  820.         Page structuring and formatting messages
  821.  
  822. }
  823. FUNCTION Send_GXPostScriptDoPageSetup(pageFormat: gxFormat; thePage: LONGINT; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  824. FUNCTION Forward_GXPostScriptDoPageSetup(pageFormat: gxFormat; thePage: LONGINT; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  825. FUNCTION Send_GXPostScriptSelectPaperType(thePapertype: gxPaperType; thePage: LONGINT; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  826. FUNCTION Forward_GXPostScriptSelectPaperType(thePapertype: gxPaperType; thePage: LONGINT; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  827. FUNCTION Send_GXPostScriptDoPageTrailer(imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  828. FUNCTION Forward_GXPostScriptDoPageTrailer(imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  829. FUNCTION Send_GXPostScriptEjectPage(thePapertype: gxPaperType; pagenumber: LONGINT; copiescount: LONGINT; erasepage: LONGINT; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  830. FUNCTION Forward_GXPostScriptEjectPage(thePapertype: gxPaperType; pagenumber: LONGINT; copiescount: LONGINT; erasepage: LONGINT; imageDataHdl: gxPostScriptImageDataHdl): OSErr; C;
  831. FUNCTION Send_GXPostScriptEjectPendingPage(VAR pageWasEjected: BOOLEAN): OSErr; C;
  832. FUNCTION Forward_GXPostScriptEjectPendingPage(VAR pageWasEjected: BOOLEAN): OSErr; C;
  833. {
  834.  
  835.         Shape imaging messages
  836.  
  837. }
  838. FUNCTION Send_GXPostScriptProcessShape(page: gxShape; trcount: LONGINT; trlist: gxTransform): OSErr; C;
  839. FUNCTION Forward_GXPostScriptProcessShape(page: gxShape; trcount: LONGINT; trlist: gxTransform): OSErr; C;
  840. { ------------------------------------------------------------------------------
  841.  
  842.                                             Driver API Functions
  843.  
  844. -------------------------------------------------------------------------------- }
  845.  
  846. CONST
  847.     gxMissingImagePointer        = -4;
  848.  
  849.  
  850. FUNCTION GXAddPrinterViewDevice(thePrinter: gxPrinter; theViewDevice: gxViewDevice): OSErr; C;
  851. FUNCTION GXGetAvailableJobFormatModes(VAR theFormatModes: gxJobFormatModeTableHdl): OSErr; C;
  852. FUNCTION GXSetPreferredJobFormatMode(theFormatMode: gxJobFormatMode; directOnly: BOOLEAN): OSErr; C;
  853. FUNCTION GXPrintingAlert(iconId: LONGINT; txtSize: LONGINT; defaultTitleNum: LONGINT; cancelTitleNum: LONGINT; textLength: LONGINT; pAlertMsg: Ptr; actionTitle: StringPtr; title2: StringPtr; title3: StringPtr; msgFont: StringPtr; filterProc: ModalFilterUPP; VAR itemHit: INTEGER; alertTitle: StringPtr): OSErr; C;
  854. FUNCTION GXGetPrintingAlert(alertResId: LONGINT; filterProc: ModalFilterUPP; VAR itemHit: INTEGER): OSErr; C;
  855. FUNCTION GXFetchDTPData(VAR dtpName: Str31; theType: OSType; theID: LONGINT; VAR theData: Handle): OSErr; C;
  856. FUNCTION GXWriteDTPData(VAR dtpName: Str31; theType: OSType; theID: LONGINT; theData: Handle): OSErr; C;
  857. FUNCTION GXHandleChooserMessage(VAR aJob: gxJob; VAR driverName: Str31; message: LONGINT; caller: LONGINT; objName: StringPtr; zoneName: StringPtr; theList: ListHandle; p2: LONGINT): OSErr; C;
  858.  
  859. {$ALIGN RESET}
  860. {$POP}
  861.  
  862. {$SETC UsingIncludes := GXPrinterDriversIncludes}
  863.  
  864. {$ENDC} {__GXPRINTERDRIVERS__}
  865.  
  866. {$IFC NOT UsingIncludes}
  867.  END.
  868. {$ENDC}
  869.